﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SIMCObjetoNegocio;
using SIMCRepositorio;
using SIMCReglasNegocio;
using Helper;

namespace SIMCFachadaNegocio
{
    public class FachadaPortafolio : FachadaBase
    {
        private IRepositorioPortafolio m_PortafolioRepositorio = DatabaseAccess.PortafolioRepositorio;
        private IRepositorioPortafolioUsuario m_PortafolioUsuarioRepositorio = DatabaseAccess.PortafolioUsuarioRepositorio;
        private IRepositorioFiltro m_FiltrosRepositorio = DatabaseAccess.FiltroRepositorio;

        public Portafolio BuscarPortafolio(int p_IdPortafolio, DateTime p_Fecha, bool p_ConsolidaPosiciones = true)
        {
            try
            {
                return m_PortafolioRepositorio.Buscar(p_IdPortafolio, p_Fecha, p_ConsolidaPosiciones);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public Portafolio BuscarPortafolioExterno(PortafolioSearchCriteria p_Criterios, bool p_ConsolidaPosiciones = true)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarExterno(p_Criterios, p_ConsolidaPosiciones);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public PortafolioBalance BuscarBalance(int p_IdPortafolio, DateTime p_Fecha )
        {
            try
            {
                return m_PortafolioRepositorio.BuscarBalance(p_IdPortafolio, p_Fecha);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public IList<string> BuscarTiposPortafoliosPorUsuario(Usuario p_Usuario)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarTiposPortafolioAcceso(p_Usuario);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public IList<PortafolioBalancePosicion> BuscarPosiciones(int p_IdPortafolio, DateTime p_Fecha)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarPosiciones(p_IdPortafolio, p_Fecha);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public PagedResult<Portafolio> BuscarListaPortafolio(PortafolioSearchCriteria p_Criterio, int start, int max = 20)
        {
            try
            {
                if (p_Criterio.EsUsuarioInterno)
                {
                    FiltroPortafolio filtro = BuscarFiltroPorPerfil(p_Criterio.CodigoRol);//Este metodo debe traer solo un filtro
                    
                    if (p_Criterio.TienePortafoliosAsociados && filtro != null)
                    {
                        return m_PortafolioRepositorio.BuscarLista(p_Criterio, start, max, filtro);
                    }
                }
                else
                {
                    return m_PortafolioRepositorio.BuscarListaExterna(p_Criterio, start, max);
                }
                return null;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }    

        #region Estados de Portafolio Usuario

        public void SolicitarPermisos(PortafolioDeUsuario p_PortafolioUsuario)
        {
            try
            {
                AgregarRegla(new ExistePortafolioAsociado(m_PortafolioUsuarioRepositorio, p_PortafolioUsuario));

                if (EsValido)
                {
                    p_PortafolioUsuario.Solicitar(CrearEstado(p_PortafolioUsuario));
                }
                else
                {
                    throw new ArgumentException(MostrarReglasRotas());
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void RechazarPermisos(PortafolioDeUsuario p_PortafolioUsuario)
        {
            try
            {
                p_PortafolioUsuario.Rechazar(CrearEstado(p_PortafolioUsuario));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void InactivarPermisos(PortafolioDeUsuario p_PortafolioUsuario)
        {
            try
            {
                p_PortafolioUsuario.Inactivar(CrearEstado(p_PortafolioUsuario));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void AprobarPermisos(PortafolioDeUsuario p_PortafolioUsuario)
        {
            try
            {
                p_PortafolioUsuario.Aprobar(CrearEstado(p_PortafolioUsuario));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void RenovarPermisos(PortafolioDeUsuario p_PortafolioUsuario)
        {
            try
            {
                p_PortafolioUsuario.Renovar(CrearEstado(p_PortafolioUsuario));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public IPortafolioUsuarioState CrearEstado(PortafolioDeUsuario p_Objeto)
        {
            switch (p_Objeto.Estado)
            {
                case EstadoPortafolioUsuario.Nuevo:
                    return new NuevoPortafolioUsuarioState(m_PortafolioUsuarioRepositorio, p_Objeto);

                case EstadoPortafolioUsuario.Rechazado:
                    return new RechazadoPortafolioUsuarioState(m_PortafolioUsuarioRepositorio, p_Objeto);

                case EstadoPortafolioUsuario.Solicitado:
                    return new SolicitadoPortafolioUsuarioState(m_PortafolioUsuarioRepositorio, p_Objeto);

                case EstadoPortafolioUsuario.Aprobado:
                    return new AprobadoPortafolioUsuarioState(m_PortafolioUsuarioRepositorio, p_Objeto);

                default:
                    throw new ArgumentException("No existe el estado");
            }
        } 
        #endregion

        public IList<PortafolioDeUsuario> BuscarListaAsociacion(int p_IdPortafolio)
        {
            try
            {
                return m_PortafolioUsuarioRepositorio.BuscarPortafolioUsuarios(p_IdPortafolio);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }        

        public List<PortafolioPermiso> BuscarListaPermiso()
        {
            try
            {
                return m_PortafolioUsuarioRepositorio.BuscarPortafolioPermisos();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public PortafolioDeUsuario BuscarAsociacion(int p_IdPortafolioUsuario)
        {
            try
            {
                return m_PortafolioUsuarioRepositorio.BuscarPortafolioUsuario(p_IdPortafolioUsuario);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public TipoPortafolioCollection BuscarTiposPortafolioCollection(PortafolioSearchCriteria criterio, int start, int max)
        {
             PagedResult<Portafolio> t_portafoliosPaginados = null;
             t_portafoliosPaginados = this.BuscarListaPortafolio(criterio, start, max);

             TipoPortafolioCollection t_Portafolios = new TipoPortafolioCollection();

             t_Portafolios.Agregar(t_portafoliosPaginados.Result.ToList());

             return t_Portafolios;
        }

        public void GuardarAlias(int p_IdPortafolioUsuario, string p_Alias)
        {
            try
            {
                m_PortafolioUsuarioRepositorio.GuardarAlias(p_IdPortafolioUsuario, p_Alias);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #region Filtros
        public FiltroPortafolio BuscarFiltroPorId(int p_IdFiltro)
        {
            try
            {
                return m_FiltrosRepositorio.Buscar(p_IdFiltro);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public List<FiltroPortafolio> BuscarFiltros()
        {
            try
            {
                return m_FiltrosRepositorio.Buscar();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public FiltroPortafolio BuscarFiltroPorPerfil(string IdRol)
        {
            try
            {
                return m_FiltrosRepositorio.BuscarPorPerfil(IdRol);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public List<Rol> BuscarPerfilesAsociados(int idfiltro)
        {
            try
            {
                return m_FiltrosRepositorio.BuscarPerfilesAsociados(idfiltro);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }

        public List<Rol> BuscarPerfilesSinFiltros()
        {
            try
            {
                return m_FiltrosRepositorio.BuscarPerfilesSinFiltro();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public int CrearFiltro(FiltroPortafolio Filtro)
        {
            try
            {
                return m_FiltrosRepositorio.Crear(Filtro);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }


        public void ActualizarFiltro(FiltroPortafolio Filtro)
        {
            try
            {
                m_FiltrosRepositorio.Actualizar(Filtro);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void AsociarPerfiles(int p_IdFiltro, List<string> p_Perfiles)
        {
            try
            {
                m_FiltrosRepositorio.AsociarPerfiles(p_IdFiltro, p_Perfiles);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        
        public List<Movimiento> BuscarMovimientos(int p_idcuenta, DateTime p_fecha, int p_idtitular)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarMovimientos(p_idcuenta, p_fecha, p_idtitular);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public List<PortafolioBalancePosicion> BuscarListaPosiciones(PortafolioBalancePosicionSearchCriteria p_Criterio, DateTime p_Fecha)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarListaPosiciones(p_Criterio, p_Fecha);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool UsuarioTienePermiso(string nombreUsuario, int idPortafolio, string tipoPermiso)
        {
            try
            {
                return m_PortafolioUsuarioRepositorio.BuscarPortafolioPermisos(nombreUsuario, idPortafolio, tipoPermiso) != null;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public List<AporteORetiro> BuscarAporteORetiros(int p_Idportafolio, DateTime p_FechaInicial, DateTime p_FechaFinal)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarListaAporteORetiros(p_Idportafolio, p_FechaInicial, p_FechaFinal);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public ResumenAportesYRetiros BuscarResumenAportesYRetiros(int p_Idportafolio, DateTime p_FechaInicial, DateTime p_FechaFinal)
        {
            try
            {
                return m_PortafolioRepositorio.BuscarResumenAportesYRetiros(p_Idportafolio, p_FechaInicial, p_FechaFinal);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}
